import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;



/**
 * Class ServidorP2PImpl
 */
public class ServidorP2PImpl extends UnicastRemoteObject implements IServidorP2P {

  //
  // Fields
  //
    String sFichero = "p2p.txt";


  
  //
  // Constructors
  //
  public ServidorP2PImpl () throws RemoteException
  { 
      
  }
  
  //
  // Methods
  //


  //
  // Accessor methods
  //

  //
  // Other methods
  //

  /**
   * Registra Nodo Y Recibe Arreglo Con las carpetas a compartir
   */
 
  
  public String obtener_ip(String direccion)
  {
      String ip = null;
      Vector<String> cadena = new Vector<String>();
      cadena = clasificar_informacion(direccion);      
      Vector<String> resultado = new Vector<String>();
      StringTokenizer directorio_txt = new StringTokenizer(cadena.firstElement(), ":");
            
      while(directorio_txt.hasMoreTokens())
      {
         resultado.addElement(directorio_txt.nextToken());
      }
      ip = resultado.firstElement();
      
      return ip;
  }
  
  public String obtener_puerto(String direccion)
  {
      String spuerto = null;
      Vector<String> cadena = new Vector<String>();
      cadena = clasificar_informacion(direccion);
      
      Vector<String> resultado = new Vector<String>();
      StringTokenizer directorio_txt = new StringTokenizer(cadena.firstElement(), ":");
            
      while(directorio_txt.hasMoreTokens())
      {
         resultado.addElement(directorio_txt.nextToken());
      }
      spuerto = resultado.lastElement();
      
      
      
      
      return spuerto;
  }
  
  /*
   * Escribe en el archivo txt los directorios y archivos a compartir
   * 
   */
  public void registrar(Vector <String> directorios , String direccion )
  {
     System.out.println("Registrando en el servidor...");
     File fichero = new File(sFichero);
     if (fichero.exists()) 
     {
         
            try {
                BufferedWriter bw = new BufferedWriter(new FileWriter(sFichero,true));
                PrintWriter escribir = new PrintWriter(bw);
                System.out.println(fichero.setWritable(true));
                
                for (int i = 0; i < directorios.size(); i++) {
                    //bw.write(directorios.elementAt(i));
                    escribir.println(direccion  + directorios.elementAt(i));
                    System.out.println("Escribio: " + directorios.elementAt(i));
                }
                
                escribir.close();
            } catch (IOException ex) {
                Logger.getLogger(ServidorP2PImpl.class.getName()).log(Level.SEVERE, null, ex);
            }
     }else
     {
         System.out.println("No Existe El Archivo");
     }
     
  }


  /**
   * Envia la peticion a un nodo de cambio de directorio
   * @param        directorio (cd)
   */
 
  public void cambiar_directorio( String directorio )throws RemoteException
  {
  }


  /**
   * Recibe el Arreglo con la informacion del Directorio y posteriormente invocara el
   * metodo mostrar lista en el nodo. (Comando ls)
   * @param        dir
   */

    @Override
  public void actualizar_directorio( String [] dir )throws RemoteException
  {
         
  }
    
    
  /*
     * retorna el directorio o archivo perteneciente a una carpeta 
     * especifica
  */
  public String listar_contenido(Vector<String> a,Vector<String> b)
  {
      String resultado = null;
      int size = b.size();
      int contador = 0 ;
      int errores = 0;
      
      if (a.size() > b.size()){
          while(contador < size)
          {
              if (!(a.get(contador).equals(b.get(contador))))
              {
                  errores++;
                  contador = size;
              }
              contador++;
          }
      }else
      {
          errores++;
      }
      
      
      if (errores > 0 )
          return "";
      else
          resultado = a.get(size);
          return resultado;
      
  }
  
  public void find(String archivo) throws RemoteException
  {
      String directorios [] = consultar_directorio("/");
      Vector<String> directorio = new Vector<String>();
      Vector<String> busqueda = new Vector<String>();
      
      for (int i = 0; i < directorio.size(); i++) {      
        directorio = clasificar_informacion(directorios[i]);
        //comparar_vectores();
      }
      
      
  }

    /* Toma una direccion. ej  Nodo1/descargas  y retorna un vector
     * cuyo contenido es la misma direccion partida 
     */
  public Vector<String> clasificar_informacion(String direccion)
  {
      Vector<String> resultado = new Vector<String>();
      String auxiliar = direccion;
      StringTokenizer directorio_txt = new StringTokenizer(auxiliar, "/");
            
      while(directorio_txt.hasMoreTokens())
      {
         resultado.addElement(directorio_txt.nextToken());
      }
            
            //System.out.println(cadena1.get(0));
      
      return resultado;
  } 

  /**
   * Retorna la lista de los directorios compartidos
   * @return       String []  (Comando ls)
   */
    

    @Override
  public String [] consultar_directorio(String direccion )throws RemoteException
  {
      String [] directorios = null;
      FileReader fr = null;
      BufferedReader bf = null;
      String auxiliar = null;
      Boolean elemento_repetido = false;
      
      
        try {
            fr = new FileReader("p2p.txt");
        } catch (FileNotFoundException ex) {
            Logger.getLogger(ServidorP2PImpl.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        bf = new BufferedReader(fr);
        
      
      
        try {
                 
            Vector<String> cadena1 = new Vector<String>();
            Vector<String> cadena2 = new Vector<String>();
            Vector<String> resultado = new Vector<String>();
            cadena2 = clasificar_informacion(direccion);
            
            while ((auxiliar = bf.readLine()) != null){
                if (!(auxiliar.equals(""))){

                    cadena1 = clasificar_informacion(auxiliar);
                    auxiliar = listar_contenido(cadena1, cadena2);
                    
                    if (!(auxiliar.equals(""))){
                        for (int i = 0; i < resultado.size(); i++) {
                            if(auxiliar.equals(resultado.elementAt(i)))
                            {
                                elemento_repetido = true;
                            }
                        }
                        if(!elemento_repetido){
                            resultado.addElement(auxiliar);
                        }else
                        {
                            elemento_repetido = false;
                        }
                    }
                    
                                
                }
            }
            directorios = new String[resultado.size()];
            for (int i = 0; i < resultado.size(); i++ )
            {
                directorios[i] = resultado.get(i);
            } 

             
        } catch (IOException ex) {
            Logger.getLogger(ServidorP2PImpl.class.getName()).log(Level.SEVERE, null, ex);
        }
      
      
      return directorios;
  }
  
    /*
     * Determina si el vector b esta contenido en el vector a
     */
    
  public boolean  comparar_vectores(Vector<String> a,Vector<String> b )
  {
      Boolean iguales = true;
      
      if(a.size() > b.size()){
            for (int i = 0; i < b.size(); i++) {          
                if(!(a.elementAt(i).equals(b.elementAt(i))))
                {
                    iguales = false;
                    i=a.size();
                }
            }
      }else
      {
          iguales = false;
      }
   
      return iguales;
  }
  
  
  
  /*
   * Determina si la direccion introducida por el usuario es valida
   */
  public boolean validar_directorio(String direccion)throws RemoteException
  {
      
      FileReader fr = null;
      BufferedReader bf = null;
      String auxiliar = null;
      Boolean direccion_valida = false;
        
        try {
            fr = new FileReader("p2p.txt");
        } catch (FileNotFoundException ex) {
            Logger.getLogger(ServidorP2PImpl.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        bf = new BufferedReader(fr);
        
      
      
        try {
                 
            Vector<String> cadena1 = new Vector<String>();
            Vector<String> resultado = new Vector<String>();
            Vector<String> cadena2 = new Vector<String>();
            cadena2 = clasificar_informacion(direccion);
            
            while (!direccion_valida &&((auxiliar = bf.readLine()) != null)){
                if (!(auxiliar.equals(""))){

                    cadena1 = clasificar_informacion(auxiliar);
                    if (comparar_vectores(cadena1, cadena2))
                    {
                        direccion_valida = true;
                    }
                    //auxiliar = listar_contenido(cadena1, cadena2);
                }
            }
        }catch (IOException ex) {
            Logger.getLogger(ServidorP2PImpl.class.getName()).log(Level.SEVERE, null, ex);
        }
      
      
      return direccion_valida;   
  }


  /**
   * Recibe el nombre del archivo completo incluyendo el nodo a transmitir
   * @param        archivo (Comando cp)
   */
 
    @Override
  public void seleccionar_archivo( String archivo )throws RemoteException
  {
  }


}
